home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / a_utils / yacc / flexyacc / aflex.lha / aflex / src / mainB.a < prev    next >
Text File  |  1993-05-31  |  18KB  |  530 lines
  1. -- Copyright (c) 1990 Regents of the University of California.
  2. -- All rights reserved.
  3. --
  4. -- This software was developed by John Self of the Arcadia project
  5. -- at the University of California, Irvine.
  6. --
  7. -- Redistribution and use in source and binary forms are permitted
  8. -- provided that the above copyright notice and this paragraph are
  9. -- duplicated in all such forms and that any documentation,
  10. -- advertising materials, and other materials related to such
  11. -- distribution and use acknowledge that the software was developed
  12. -- by the University of California, Irvine.  The name of the
  13. -- University may not be used to endorse or promote products derived
  14. -- from this software without specific prior written permission.
  15. -- THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  16. -- IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  17. -- WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18.  
  19. -- TITLE main body
  20. -- AUTHOR: John Self (UCI)
  21. -- DESCRIPTION driver routines for aflex.  Calls drivers for all
  22. -- high level routines from other packages.
  23. -- $Header: /dc/uc/self/arcadia/aflex/ada/src/RCS/mainB.a,v 1.26 1992/12/29 22:46:15 self Exp self $ 
  24.  
  25. with MISC_DEFS, MISC, COMMAND_LINE_INTERFACE, DFA, ECS, GEN, TEXT_IO, PARSER; 
  26. with MAIN_BODY, TSTRING, PARSE_TOKENS, SKELETON_MANAGER, EXTERNAL_FILE_MANAGER; 
  27. with EXTERNAL_FILE_MANAGER, INT_IO; use MISC_DEFS, COMMAND_LINE_INTERFACE, 
  28.   TSTRING, EXTERNAL_FILE_MANAGER; 
  29.  
  30. package body MAIN_BODY is 
  31.   OUTFILE_CREATED    : BOOLEAN := FALSE; 
  32.   AFLEX_VERSION      : CONSTANT STRING := "1.3a"; 
  33.   STARTTIME, ENDTIME : VSTRING; 
  34.  
  35.   -- aflexend - terminate aflex
  36.   --
  37.   -- note
  38.   --    This routine does not return.
  39.  
  40.   procedure AFLEXEND(STATUS : in INTEGER) is 
  41.     use TEXT_IO; 
  42.     TBLSIZ : INTEGER; 
  43.   begin
  44.     TERMINATION_STATUS := STATUS; 
  45.  
  46.     -- we'll return this value of the OS.
  47.     if (IS_OPEN(SKELFILE)) then 
  48.       CLOSE(SKELFILE); 
  49.     end if; 
  50.  
  51.     if (IS_OPEN(TEMP_ACTION_FILE)) then 
  52.       DELETE(TEMP_ACTION_FILE); 
  53.     end if; 
  54.  
  55.     if (IS_OPEN(DEF_FILE)) then 
  56.       DELETE(DEF_FILE); 
  57.     end if; 
  58.  
  59.     if (BACKTRACK_REPORT) then 
  60.       if (NUM_BACKTRACKING = 0) then 
  61.         TEXT_IO.PUT_LINE(BACKTRACK_FILE, "No backtracking."); 
  62.       else 
  63.         if (FULLTBL) then 
  64.           INT_IO.PUT(BACKTRACK_FILE, NUM_BACKTRACKING, 0); 
  65.           TEXT_IO.PUT_LINE(BACKTRACK_FILE, 
  66.             " backtracking (non-accepting) states."); 
  67.         else 
  68.           TEXT_IO.PUT_LINE(BACKTRACK_FILE, "Compressed tables always backtrack."
  69.             ); 
  70.         end if; 
  71.       end if; 
  72.  
  73.       CLOSE(BACKTRACK_FILE); 
  74.     end if; 
  75.  
  76.     if (PRINTSTATS) then 
  77.       ENDTIME := MISC.AFLEX_GETTIME; 
  78.  
  79.       TEXT_IO.PUT_LINE(STANDARD_ERROR, "aflex version " & AFLEX_VERSION & 
  80.         " usage statistics:"); 
  81.  
  82.       TSTRING.PUT_LINE(STANDARD_ERROR, "  started at " & STARTTIME & 
  83.         ", finished at " & ENDTIME); 
  84.       TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  85.       INT_IO.PUT(STANDARD_ERROR, LASTNFA, 0); 
  86.       TEXT_IO.PUT(STANDARD_ERROR, '/'); 
  87.       INT_IO.PUT(STANDARD_ERROR, CURRENT_MNS, 0); 
  88.       TEXT_IO.PUT_LINE(STANDARD_ERROR, "  NFA states"); 
  89.  
  90.       TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  91.       INT_IO.PUT(STANDARD_ERROR, LASTDFA, 0); 
  92.       TEXT_IO.PUT(STANDARD_ERROR, '/'); 
  93.       INT_IO.PUT(STANDARD_ERROR, CURRENT_MAX_DFAS, 0); 
  94.       TEXT_IO.PUT(STANDARD_ERROR, " DFA states ("); 
  95.       INT_IO.PUT(STANDARD_ERROR, TOTNST, 0); 
  96.       TEXT_IO.PUT(STANDARD_ERROR, "  words)"); 
  97.  
  98.       TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  99.       INT_IO.PUT(STANDARD_ERROR, NUM_RULES - 1, 0); 
  100.  
  101.       -- - 1 for def. rule
  102.       TEXT_IO.PUT_LINE(STANDARD_ERROR, "  rules"); 
  103.  
  104.       if (NUM_BACKTRACKING = 0) then 
  105.         TEXT_IO.PUT_LINE(STANDARD_ERROR, "  No backtracking"); 
  106.       else 
  107.         if (FULLTBL) then 
  108.           TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  109.           INT_IO.PUT(STANDARD_ERROR, NUM_BACKTRACKING, 0); 
  110.           TEXT_IO.PUT_LINE(STANDARD_ERROR, 
  111.             "  backtracking (non-accepting) states"); 
  112.         else 
  113.           TEXT_IO.PUT_LINE(STANDARD_ERROR, " compressed tables always backtrack"
  114.             ); 
  115.         end if; 
  116.       end if; 
  117.  
  118.       if (BOL_NEEDED) then 
  119.         TEXT_IO.PUT_LINE(STANDARD_ERROR, "  Beginning-of-line patterns used"); 
  120.       end if; 
  121.  
  122.       TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  123.       INT_IO.PUT(STANDARD_ERROR, LASTSC, 0); 
  124.       TEXT_IO.PUT(STANDARD_ERROR, '/'); 
  125.       INT_IO.PUT(STANDARD_ERROR, CURRENT_MAX_SCS, 0); 
  126.       TEXT_IO.PUT_LINE(STANDARD_ERROR, " start conditions"); 
  127.  
  128.       TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  129.       INT_IO.PUT(STANDARD_ERROR, NUMEPS, 0); 
  130.       TEXT_IO.PUT(STANDARD_ERROR, " epsilon states, "); 
  131.       INT_IO.PUT(STANDARD_ERROR, EPS2, 0); 
  132.       TEXT_IO.PUT_LINE(STANDARD_ERROR, "  double epsilon states"); 
  133.  
  134.       if (LASTCCL = 0) then 
  135.         TEXT_IO.PUT_LINE(STANDARD_ERROR, "  no character classes"); 
  136.       else 
  137.         TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  138.         INT_IO.PUT(STANDARD_ERROR, LASTCCL, 0); 
  139.         TEXT_IO.PUT(STANDARD_ERROR, '/'); 
  140.         INT_IO.PUT(STANDARD_ERROR, CURRENT_MAXCCLS, 0); 
  141.         TEXT_IO.PUT(STANDARD_ERROR, " character classes needed "); 
  142.         INT_IO.PUT(STANDARD_ERROR, CCLMAP(LASTCCL) + CCLLEN(LASTCCL), 0); 
  143.         TEXT_IO.PUT(STANDARD_ERROR, '/'); 
  144.         INT_IO.PUT(STANDARD_ERROR, CURRENT_MAX_CCL_TBL_SIZE, 0); 
  145.         TEXT_IO.PUT(STANDARD_ERROR, " words of storage, "); 
  146.         INT_IO.PUT(STANDARD_ERROR, CCLREUSE, 0); 
  147.         TEXT_IO.PUT_LINE(STANDARD_ERROR, "reused"); 
  148.       end if; 
  149.  
  150.       TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  151.       INT_IO.PUT(STANDARD_ERROR, NUMSNPAIRS, 0); 
  152.       TEXT_IO.PUT_LINE(STANDARD_ERROR, " state/nextstate pairs created"); 
  153.  
  154.       TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  155.       INT_IO.PUT(STANDARD_ERROR, NUMUNIQ, 0); 
  156.       TEXT_IO.PUT(STANDARD_ERROR, '/'); 
  157.       INT_IO.PUT(STANDARD_ERROR, NUMDUP, 0); 
  158.       TEXT_IO.PUT_LINE(STANDARD_ERROR, " unique/duplicate transitions"); 
  159.  
  160.       if (FULLTBL) then 
  161.         TBLSIZ := LASTDFA*NUMECS; 
  162.         TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  163.         INT_IO.PUT(STANDARD_ERROR, TBLSIZ, 0); 
  164.         TEXT_IO.PUT_LINE(STANDARD_ERROR, " table entries"); 
  165.       else 
  166.         TBLSIZ := 2*(LASTDFA + NUMTEMPS) + 2*TBLEND; 
  167.  
  168.         TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  169.         INT_IO.PUT(STANDARD_ERROR, LASTDFA + NUMTEMPS, 0); 
  170.         TEXT_IO.PUT(STANDARD_ERROR, '/'); 
  171.         INT_IO.PUT(STANDARD_ERROR, CURRENT_MAX_DFAS, 0); 
  172.         TEXT_IO.PUT_LINE(STANDARD_ERROR, " base-def entries created"); 
  173.  
  174.         TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  175.         INT_IO.PUT(STANDARD_ERROR, TBLEND, 0); 
  176.         TEXT_IO.PUT(STANDARD_ERROR, '/'); 
  177.         INT_IO.PUT(STANDARD_ERROR, CURRENT_MAX_XPAIRS, 0); 
  178.         TEXT_IO.PUT(STANDARD_ERROR, " (peak "); 
  179.         INT_IO.PUT(STANDARD_ERROR, PEAKPAIRS, 0); 
  180.         TEXT_IO.PUT_LINE(STANDARD_ERROR, ") nxt-chk entries created"); 
  181.  
  182.         TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  183.         INT_IO.PUT(STANDARD_ERROR, NUMTEMPS*NUMMECS, 0); 
  184.         TEXT_IO.PUT(STANDARD_ERROR, '/'); 
  185.         INT_IO.PUT(STANDARD_ERROR, CURRENT_MAX_TEMPLATE_XPAIRS, 0); 
  186.         TEXT_IO.PUT(STANDARD_ERROR, " (peak "); 
  187.         INT_IO.PUT(STANDARD_ERROR, NUMTEMPS*NUMECS, 0); 
  188.         TEXT_IO.PUT_LINE(STANDARD_ERROR, ") template nxt-chk entries created"); 
  189.  
  190.         TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  191.         INT_IO.PUT(STANDARD_ERROR, NUMMT, 0); 
  192.         TEXT_IO.PUT_LINE(STANDARD_ERROR, " empty table entries"); 
  193.         TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  194.         INT_IO.PUT(STANDARD_ERROR, NUMPROTS, 0); 
  195.         TEXT_IO.PUT_LINE(STANDARD_ERROR, " protos created"); 
  196.         TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  197.         INT_IO.PUT(STANDARD_ERROR, NUMTEMPS, 0); 
  198.         TEXT_IO.PUT(STANDARD_ERROR, " templates created, "); 
  199.         INT_IO.PUT(STANDARD_ERROR, TMPUSES, 0); 
  200.         TEXT_IO.PUT_LINE(STANDARD_ERROR, "uses"); 
  201.       end if; 
  202.  
  203.       if (USEECS) then 
  204.         TBLSIZ := TBLSIZ + CSIZE; 
  205.         TEXT_IO.PUT_LINE(STANDARD_ERROR, "  "); 
  206.         INT_IO.PUT(STANDARD_ERROR, NUMECS, 0); 
  207.         TEXT_IO.PUT(STANDARD_ERROR, '/'); 
  208.         INT_IO.PUT(STANDARD_ERROR, CSIZE, 0); 
  209.         TEXT_IO.PUT_LINE(STANDARD_ERROR, " equivalence classes created"); 
  210.       end if; 
  211.  
  212.       if (USEMECS) then 
  213.         TBLSIZ := TBLSIZ + NUMECS; 
  214.         TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  215.         INT_IO.PUT(STANDARD_ERROR, NUMMECS, 0); 
  216.         TEXT_IO.PUT(STANDARD_ERROR, '/'); 
  217.         INT_IO.PUT(STANDARD_ERROR, CSIZE, 0); 
  218.         TEXT_IO.PUT_LINE(STANDARD_ERROR, " meta-equivalence classes created"); 
  219.       end if; 
  220.  
  221.       TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  222.       INT_IO.PUT(STANDARD_ERROR, HSHCOL, 0); 
  223.       TEXT_IO.PUT(STANDARD_ERROR, " ("); 
  224.       INT_IO.PUT(STANDARD_ERROR, HSHSAVE, 0); 
  225.       TEXT_IO.PUT_LINE(STANDARD_ERROR, " saved) hash collisions, "); 
  226.       INT_IO.PUT(STANDARD_ERROR, DFAEQL, 0); 
  227.       TEXT_IO.PUT_LINE(STANDARD_ERROR, " DFAs equal"); 
  228.  
  229.       TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  230.       INT_IO.PUT(STANDARD_ERROR, NUM_REALLOCS, 0); 
  231.       TEXT_IO.PUT_LINE(STANDARD_ERROR, " sets of reallocations needed"); 
  232.       TEXT_IO.PUT(STANDARD_ERROR, "  "); 
  233.       INT_IO.PUT(STANDARD_ERROR, TBLSIZ, 0); 
  234.       TEXT_IO.PUT_LINE(STANDARD_ERROR, " total table entries needed"); 
  235.     end if; 
  236.  
  237.     if (STATUS /= 0) then 
  238.       raise AFLEX_TERMINATE; 
  239.     end if; 
  240.   end AFLEXEND; 
  241.  
  242.   -- aflexinit - initialize aflex
  243.  
  244.   procedure AFLEXINIT is 
  245.     use TEXT_IO, TSTRING; 
  246.     SAWCMPFLAG, USE_STDOUT : BOOLEAN; 
  247.     OUTPUT_FILE            : FILE_TYPE; 
  248.     INPUT_FILE             : FILE_TYPE; 
  249.     I                      : INTEGER; 
  250.     ARG_CNT                : INTEGER; 
  251.     FLAG_POS               : INTEGER; 
  252.     ARG                    : VSTRING; 
  253.     SKELNAME               : VSTRING; 
  254.     SKELNAME_USED          : BOOLEAN := FALSE; 
  255.   begin
  256.     PRINTSTATS := FALSE; 
  257.     SYNTAXERROR := FALSE; 
  258.     TRACE := FALSE; 
  259.     SPPRDFLT := FALSE; 
  260.     INTERACTIVE := FALSE; 
  261.     CASEINS := FALSE; 
  262.     BACKTRACK_REPORT := FALSE; 
  263.     PERFORMANCE_REPORT := FALSE; 
  264.     DDEBUG := FALSE; 
  265.     FULLTBL := FALSE; 
  266.     CONTINUED_ACTION := FALSE; 
  267.     GEN_LINE_DIRS := TRUE; 
  268.     USEMECS := TRUE; 
  269.     USEECS := TRUE; 
  270.  
  271.     SAWCMPFLAG := FALSE; 
  272.     USE_STDOUT := FALSE; 
  273.  
  274.     -- read flags
  275.     COMMAND_LINE_INTERFACE.INITIALIZE_COMMAND_LINE; 
  276.  
  277.     -- load up argv
  278.     EXTERNAL_FILE_MANAGER.INITIALIZE_FILES; 
  279.  
  280.     -- do external files setup
  281.  
  282.     -- loop through the list of arguments
  283.     ARG_CNT := 1; 
  284.     while (ARG_CNT <= ARGC - 1) loop
  285.       if ((CHAR(ARGV(ARG_CNT), 1) /= '-') or (LEN(ARGV(ARG_CNT)) < 2)) then 
  286.         exit; 
  287.       end if; 
  288.  
  289.       -- loop through the flags in this argument.
  290.       ARG := ARGV(ARG_CNT); 
  291.       FLAG_POS := 2; 
  292.       while (FLAG_POS <= LEN(ARG)) loop
  293.         case CHAR(ARG, FLAG_POS) is 
  294.           when 'b' => 
  295.             BACKTRACK_REPORT := TRUE; 
  296.           when 'd' => 
  297.             DDEBUG := TRUE; 
  298.           when 'f' => 
  299.             USEECS := FALSE; 
  300.             USEMECS := FALSE; 
  301.             FULLTBL := TRUE; 
  302.           when 'I' => 
  303.             INTERACTIVE := TRUE; 
  304.           when 'i' => 
  305.             CASEINS := TRUE; 
  306.           when 'L' => 
  307.             GEN_LINE_DIRS := FALSE; 
  308.           when 'p' => 
  309.             PERFORMANCE_REPORT := TRUE; 
  310.           when 'S' => 
  311.             if (FLAG_POS /= 2) then 
  312.               MISC.AFLEXERROR("-S flag must be given separately"); 
  313.             end if; 
  314.             SKELNAME := SLICE(ARG, FLAG_POS + 1, LEN(ARG)); 
  315.             SKELNAME_USED := TRUE; 
  316.             goto GET_NEXT_ARG; 
  317.           when 's' => 
  318.             SPPRDFLT := TRUE; 
  319.           when 't' => 
  320.             USE_STDOUT := TRUE; 
  321.           when 'T' => 
  322.             TRACE := TRUE; 
  323.           when 'v' => 
  324.             PRINTSTATS := TRUE; 
  325.           when others => 
  326.             MISC.AFLEXERROR("unknown flag " & CHAR(ARG, FLAG_POS)); 
  327.         end case; 
  328.         FLAG_POS := FLAG_POS + 1; 
  329.       end loop; 
  330.       <<GET_NEXT_ARG>> ARG_CNT := ARG_CNT + 1; 
  331.  
  332.     -- go on to next argument from list.
  333.     end loop; 
  334.  
  335.     if (FULLTBL and USEMECS) then 
  336.       MISC.AFLEXERROR("full table and -cm don't make sense together"); 
  337.     end if; 
  338.  
  339.     if (FULLTBL and INTERACTIVE) then 
  340.       MISC.AFLEXERROR("full table and -I are (currently) incompatible"); 
  341.     end if; 
  342.  
  343.     if (ARG_CNT < ARGC) then 
  344.       begin
  345.         if (ARG_CNT - ARGC > 1) then 
  346.           MISC.AFLEXERROR("extraneous argument(s) given"); 
  347.         end if; 
  348.  
  349.         -- Tell aflex where to read input from.
  350.         INFILENAME := ARGV(ARG_CNT); 
  351.         OPEN(INPUT_FILE, IN_FILE, STR(ARGV(ARG_CNT))); 
  352.         SET_INPUT(INPUT_FILE); 
  353.       exception
  354.         when NAME_ERROR => 
  355.           MISC.AFLEXFATAL("can't open " & INFILENAME); 
  356.       end; 
  357.     end if; 
  358.  
  359.     if (not USE_STDOUT) then 
  360.       EXTERNAL_FILE_MANAGER.GET_SCANNER_FILE(OUTPUT_FILE); 
  361.       OUTFILE_CREATED := TRUE; 
  362.     end if; 
  363.  
  364.     if (BACKTRACK_REPORT) then 
  365.       EXTERNAL_FILE_MANAGER.GET_BACKTRACK_FILE(BACKTRACK_FILE); 
  366.     end if; 
  367.  
  368.     LASTCCL := 0; 
  369.     LASTSC := 0; 
  370.  
  371.  
  372.     --initialize the statistics
  373.     STARTTIME := MISC.AFLEX_GETTIME; 
  374.  
  375.     begin
  376.  
  377.       -- open the skeleton file
  378.       if (SKELNAME_USED) then 
  379.         OPEN(SKELFILE, IN_FILE, STR(SKELNAME)); 
  380.         SKELETON_MANAGER.SET_EXTERNAL_SKELETON; 
  381.       end if; 
  382.     exception
  383.       when USE_ERROR | NAME_ERROR => 
  384.         MISC.AFLEXFATAL("couldn't open skeleton file " & SKELNAME); 
  385.     end; 
  386.  
  387.     -- without a third argument create make an anonymous temp file.
  388.     begin
  389.       CREATE(TEMP_ACTION_FILE, OUT_FILE); 
  390.       CREATE(DEF_FILE, OUT_FILE); 
  391.     exception
  392.       when USE_ERROR | NAME_ERROR => 
  393.         MISC.AFLEXFATAL("can't create temporary file"); 
  394.     end; 
  395.  
  396.     LASTDFA := 0; 
  397.     LASTNFA := 0; 
  398.     NUM_RULES := 0; 
  399.     NUMAS := 0; 
  400.     NUMSNPAIRS := 0; 
  401.     TMPUSES := 0; 
  402.     NUMECS := 0; 
  403.     NUMEPS := 0; 
  404.     EPS2 := 0; 
  405.     NUM_REALLOCS := 0; 
  406.     HSHCOL := 0; 
  407.     DFAEQL := 0; 
  408.     TOTNST := 0; 
  409.     NUMUNIQ := 0; 
  410.     NUMDUP := 0; 
  411.     HSHSAVE := 0; 
  412.     EOFSEEN := FALSE; 
  413.     DATAPOS := 0; 
  414.     DATALINE := 0; 
  415.     NUM_BACKTRACKING := 0; 
  416.     ONESP := 0; 
  417.     NUMPROTS := 0; 
  418.     VARIABLE_TRAILING_CONTEXT_RULES := FALSE; 
  419.     BOL_NEEDED := FALSE; 
  420.  
  421.     LINENUM := 1; 
  422.     SECTNUM := 1; 
  423.     FIRSTPROT := NIL; 
  424.  
  425.     -- used in mkprot() so that the first proto goes in slot 1
  426.     -- of the proto queue
  427.  
  428.     LASTPROT := 1; 
  429.  
  430.     if (USEECS) then 
  431.     -- set up doubly-linked equivalence classes
  432.       ECGROUP(1) := NIL; 
  433.  
  434.       for CNT in 2 .. CSIZE loop
  435.         ECGROUP(CNT) := CNT - 1; 
  436.         NEXTECM(CNT - 1) := CNT; 
  437.       end loop; 
  438.  
  439.       NEXTECM(CSIZE) := NIL; 
  440.     else 
  441.     -- put everything in its own equivalence class
  442.       for CNT in 1 .. CSIZE loop
  443.         ECGROUP(CNT) := CNT; 
  444.         NEXTECM(CNT) := BAD_SUBSCRIPT;  -- to catch errors
  445.       end loop; 
  446.     end if; 
  447.  
  448.     SET_UP_INITIAL_ALLOCATIONS; 
  449.  
  450.  
  451.   end AFLEXINIT; 
  452.  
  453.   -- readin - read in the rules section of the input file(s)
  454.   procedure READIN is 
  455.   begin
  456.     SKELETON_MANAGER.SKELOUT; 
  457.     TEXT_IO.PUT("with " & TSTRING.STR(MISC.BASENAME) & "_dfa" & "; "); 
  458.     TEXT_IO.PUT_LINE("use " & TSTRING.STR(MISC.BASENAME) & "_dfa" & "; "); 
  459.     TEXT_IO.PUT("with " & TSTRING.STR(MISC.BASENAME) & "_io" & "; "); 
  460.     TEXT_IO.PUT_LINE("use " & TSTRING.STR(MISC.BASENAME) & "_io" & "; "); 
  461.     MISC.LINE_DIRECTIVE_OUT; 
  462.  
  463.     PARSER.YYPARSE; 
  464.  
  465.     if (USEECS) then 
  466.       ECS.CRE8ECS(NEXTECM, ECGROUP, CSIZE, NUMECS); 
  467.       ECS.CCL2ECL; 
  468.     else 
  469.       NUMECS := CSIZE; 
  470.     end if; 
  471.   exception
  472.     when PARSE_TOKENS.SYNTAX_ERROR => 
  473.       MISC.AFLEXERROR("fatal parse error at line " & INTEGER'IMAGE(LINENUM)); 
  474.       MAIN_BODY.AFLEXEND(1); 
  475.   end READIN; 
  476.  
  477.   -- set_up_initial_allocations - allocate memory for internal tables
  478.   procedure SET_UP_INITIAL_ALLOCATIONS is 
  479.   begin
  480.     CURRENT_MNS := INITIAL_MNS; 
  481.     FIRSTST := ALLOCATE_INTEGER_ARRAY(CURRENT_MNS); 
  482.     LASTST := ALLOCATE_INTEGER_ARRAY(CURRENT_MNS); 
  483.     FINALST := ALLOCATE_INTEGER_ARRAY(CURRENT_MNS); 
  484.     TRANSCHAR := ALLOCATE_INTEGER_ARRAY(CURRENT_MNS); 
  485.     TRANS1 := ALLOCATE_INTEGER_ARRAY(CURRENT_MNS); 
  486.     TRANS2 := ALLOCATE_INTEGER_ARRAY(CURRENT_MNS); 
  487.     ACCPTNUM := ALLOCATE_INTEGER_ARRAY(CURRENT_MNS); 
  488.     ASSOC_RULE := ALLOCATE_INTEGER_ARRAY(CURRENT_MNS); 
  489.     STATE_TYPE := ALLOCATE_STATE_ENUM_ARRAY(CURRENT_MNS); 
  490.  
  491.     CURRENT_MAX_RULES := INITIAL_MAX_RULES; 
  492.     RULE_TYPE := ALLOCATE_RULE_ENUM_ARRAY(CURRENT_MAX_RULES); 
  493.     RULE_LINENUM := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_RULES); 
  494.  
  495.     CURRENT_MAX_SCS := INITIAL_MAX_SCS; 
  496.     SCSET := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_SCS); 
  497.     SCBOL := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_SCS); 
  498.     SCXCLU := ALLOCATE_BOOLEAN_ARRAY(CURRENT_MAX_SCS); 
  499.     SCEOF := ALLOCATE_BOOLEAN_ARRAY(CURRENT_MAX_SCS); 
  500.     SCNAME := ALLOCATE_VSTRING_ARRAY(CURRENT_MAX_SCS); 
  501.     ACTVSC := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_SCS); 
  502.  
  503.     CURRENT_MAXCCLS := INITIAL_MAX_CCLS; 
  504.     CCLMAP := ALLOCATE_INTEGER_ARRAY(CURRENT_MAXCCLS); 
  505.     CCLLEN := ALLOCATE_INTEGER_ARRAY(CURRENT_MAXCCLS); 
  506.     CCLNG := ALLOCATE_INTEGER_ARRAY(CURRENT_MAXCCLS); 
  507.  
  508.     CURRENT_MAX_CCL_TBL_SIZE := INITIAL_MAX_CCL_TBL_SIZE; 
  509.     CCLTBL := ALLOCATE_CHARACTER_ARRAY(CURRENT_MAX_CCL_TBL_SIZE); 
  510.  
  511.     CURRENT_MAX_DFA_SIZE := INITIAL_MAX_DFA_SIZE; 
  512.  
  513.     CURRENT_MAX_XPAIRS := INITIAL_MAX_XPAIRS; 
  514.     NXT := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_XPAIRS); 
  515.     CHK := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_XPAIRS); 
  516.  
  517.     CURRENT_MAX_TEMPLATE_XPAIRS := INITIAL_MAX_TEMPLATE_XPAIRS; 
  518.     TNXT := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_TEMPLATE_XPAIRS); 
  519.  
  520.     CURRENT_MAX_DFAS := INITIAL_MAX_DFAS; 
  521.     BASE := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_DFAS); 
  522.     DEF := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_DFAS); 
  523.     DFASIZ := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_DFAS); 
  524.     ACCSIZ := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_DFAS); 
  525.     DHASH := ALLOCATE_INTEGER_ARRAY(CURRENT_MAX_DFAS); 
  526.     DSS := ALLOCATE_INT_PTR_ARRAY(CURRENT_MAX_DFAS); 
  527.     DFAACC := ALLOCATE_DFAACC_UNION(CURRENT_MAX_DFAS); 
  528.   end SET_UP_INITIAL_ALLOCATIONS; 
  529. end MAIN_BODY; 
  530.